package Service.TransformService;

import Factory.ParamChangeUtil;
import Model.SurroundModel.Ship;
import Model.SurroundModel.Target;
import Model.TransFormModel.Path;
import Model.TransFormModel.TMat;
import Service.ShipCalculate;

import java.util.ArrayList;
import java.util.List;

/**
 * 转换示例
 *
 * @author dingN
 * @date 2022/06/22
 */// 计算层实现实例
// TODO:  实现父类的Init方法，用于输入数据的初始化
// TODO： 实现父类的Calculate方法，未来所有的算法都只用来更改输入的几项数据的具体内容：目标队列，智能体小船队列，目标中心的，船队历史运行轨迹（可根据后续需求拓展）
// TODO:  实现父类的WorkingState方法，用来外部判断计算线程是否仍在工作
// TODO:  实现父类的ShutDown方法，用来结束运行
public class TransformService extends ShipCalculate{

    ParamChangeUtil paramChangeUtil = new ParamChangeUtil(); // 数据转换器

    public static String name = "队列转换组件";

    static int SleepTime; // 计算休眠间隔
    static volatile boolean isWorking = false; // 是否运行

    // 计算实例，包含计算信息
    public ArrayList<Ship> FromShips;
    public ArrayList<Ship> EndShips;

    public Path path = new Path();
    public TMat tMat;

    /**
     * 转换示例
     * @param sleepTime 睡眠时间
     */
    public TransformService(
            int sleepTime,
            ArrayList<Ship> FromShips,
            ArrayList<Ship> EndShips
            ) {
        this.SleepTime = sleepTime;
        this.isWorking = true;
        System.out.println("zxx:" + FromShips.get(0).x);
        System.out.println("zxx:" + EndShips.get(0).x);
        this.FromShips = FromShips;
        this.EndShips = EndShips;
    }


    public void Init() {
        System.out.println(GetName() + "初始化了");
        this.initShip();
        // 保存数据
        saveData(0);
    }

    public void Calculate() {
        this.calculate();
    }

    public boolean GetWorkingState() {
        return this.isWorking;
    }

    public void ShutDown(){
        this.isWorking = false;
    };

    public String GetName() {
        return name;
    }

    public void SetCalSpeed(int sleepTime){ this.SleepTime = sleepTime;};

    // 初始化智能体
    public void initShip() {

        // 配对处理
        tMat = new TMat(FromShips.size(), FromShips, EndShips);
        tMat.pretreat();//预处理
        tMat.screen();//贪心筛选
        tMat.CRcorrect(49);
        tMat.RPcorrect(49);

//        for (int i = 1; i <= FromShips.size(); i++) {
//            tMat.SE[i][0].storeXY();
//        }

        path = new Path();
        //根据限制时间分配速度
        path.SetV(tMat.SE, 100);
        //计算角度
        path.Getθ(tMat.SE);
        //预处理碰撞的船
        path.CollisionShip(tMat.SE);

        // 保存数据
        saveData(0);
    }

    /**
     * 保存数据
     * @param time 时间
     */
    public void saveData(double time) {
        //保存目标队列当前位置
        paramChangeUtil.SaveAllData(this, time);
    }


    // 计算并更新需要更新的数据
    public void calculate() {

        isWorking = true;

        //移动
        double times = 1;
        while (!path.Finish(tMat.SE) && isWorking){

            // 休眠
            try {
                Thread.sleep(SleepTime);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            path.Calcposition(tMat.SE); //移动
            path.Storedistance(tMat.SE, 100);    //存储距离信息
            path.CalculateTabularData(tMat.SE);     //计算并存储平均距离信息

            saveData(times);
            times++;

            System.out.println("是否应该结束" + path.Finish(tMat.SE));
        }

        isWorking = false;
    }
}
